//// This file is part of the uSTL library, an STL implementation.
////
//// Copyright (c) 2005-2009 by Mike Sharov <msharov@users.sourceforge.net>
//// This file is free software, distributed under the MIT License.
//
//#ifndef UEXCEPTION_H_18DE3EF55C4F00673268F0D66546AF5D
//#define UEXCEPTION_H_18DE3EF55C4F00673268F0D66546AF5D
//
//#include "utypes.h"
//#ifndef WITHOUT_LIBSTDCPP
//    #include <exception>
//    #include <new>
//#endif
//#include "bktrace.h"
//
//#if WITHOUT_LIBSTDCPP
//namespace std {
///// If you write a replacement terminate handler, it must be of this type.
//typedef void (*terminate_handler) (void);
///// If you write a replacement unexpected handler, it must be of this type.
//typedef void (*unexpected_handler) (void);
///// Takes a new handler function as an argument, returns the old function.
//terminate_handler set_terminate (terminate_handler pHandler) throw();
///// The runtime will call this function if exception handling must be
///// abandoned for any reason.  It can also be called by the user.
//void terminate (void) __attribute__ ((__noreturn__));
///// Takes a new handler function as an argument, returns the old function.
//unexpected_handler set_unexpected (unexpected_handler pHandler) throw();
///// The runtime will call this function if an exception is thrown which
///// violates the function's exception specification.
//void unexpected (void) __attribute__ ((__noreturn__));
///// Returns true when the caught exception violates the throw specification.
//bool uncaught_exception() throw();
//} // namespace std
//#endif
//
//namespace ustl {
//
//class string;
//
//typedef uint32_t	xfmt_t;
//
//enum {
//    xfmt_Exception,
//    xfmt_BadAlloc,
//    xfmt_LibcException		= 12,
//    xfmt_FileException		= 13,
//    xfmt_StreamBoundsException	= 14
//};
//
///// \class exception uexception.h ustl.h
///// \ingroup Exceptions
/////
///// \brief Base class for exceptions, equivalent to std::exception.
/////
//#if WITHOUT_LIBSTDCPP
//class exception {
//#else
//class exception : public std::exception {
//#endif
//public:
//    typedef const CBacktrace& rcbktrace_t;
//public:
//    inline		exception (void) throw() : m_Format (xfmt_Exception) {}
//    inline virtual     ~exception (void) throw() {}
//    inline virtual const char* what (void) const throw() { return ("error"); }
//    virtual void	info (string& msgbuf, const char* fmt = NULL) const throw();
//    virtual void	read (istream& is);
//    virtual void	write (ostream& os) const;
//    void		text_write (ostringstream& os) const;
//    inline virtual size_t stream_size (void) const { return (sizeof(m_Format) + sizeof(uint32_t) + m_Backtrace.stream_size()); }
//    /// Format of the exception is used to lookup exception::info format string.
//    /// Another common use is the instantiation of serialized exceptions, used
//    /// by the error handler node chain to troubleshoot specific errors.
//    inline xfmt_t	format (void) const	{ return (m_Format); }
//    inline rcbktrace_t	backtrace (void) const	{ return (m_Backtrace); }
//protected:
//    inline void		set_format (xfmt_t fmt) { m_Format = fmt; }
//private:
//    CBacktrace		m_Backtrace;	///< Backtrace of the throw point.
//    xfmt_t		m_Format;	///< Format of the exception's data.
//};
//
///// \class bad_cast uexception.h ustl.h
///// \ingroup Exceptions
/////
///// \brief Thrown to indicate a bad dynamic_cast usage.
/////
//class bad_cast : public exception {
//public:
//    inline explicit		bad_cast (void) throw() : exception() {}
//    inline virtual const char*	what (void) const throw() { return ("bad cast"); }
//};
//
////----------------------------------------------------------------------
//
///// \class bad_alloc uexception.h ustl.h
///// \ingroup Exceptions
/////
///// \brief Exception thrown on memory allocation failure by memblock::reserve.
/////
//#if WITHOUT_LIBSTDCPP
//class bad_alloc : public exception {
//#else
//class bad_alloc : public std::bad_alloc, public exception {
//#endif
//public:
//    explicit		bad_alloc (size_t nBytes = 0) throw();
//    inline virtual const char*	what (void) const throw() { return ("memory allocation failed"); }
//    virtual void	info (string& msgbuf, const char* fmt = NULL) const throw();
//    virtual void	read (istream& is);
//    virtual void	write (ostream& os) const;
//    virtual size_t	stream_size (void) const;
//protected:
//    size_t		m_nBytesRequested;	///< Number of bytes requested by the failed allocation.
//};
//
///// \class libc_exception uexception.h ustl.h
///// \ingroup Exceptions
/////
///// \brief Thrown when a libc function returns an error.
/////
///// Contains an errno and description. This is a uSTL extension.
/////
//class libc_exception : public exception {
//public:
//    explicit		libc_exception (const char* operation) throw();
//			libc_exception (const libc_exception& v) throw();
//    const libc_exception& operator= (const libc_exception& v);
//    inline virtual const char*	what (void) const throw() { return ("libc function failed"); }
//    virtual void	info (string& msgbuf, const char* fmt = NULL) const throw();
//    virtual void	read (istream& is);
//    virtual void	write (ostream& os) const;
//    virtual size_t	stream_size (void) const;
//protected:
//    intptr_t		m_Errno;		///< Error code returned by the failed operation.
//    const char*		m_Operation;		///< Name of the failed operation.
//};
//
///// \class file_exception uexception.h ustl.h
///// \ingroup Exceptions
/////
///// \brief File-related exceptions.
/////
///// Contains the file name. This is a uSTL extension.
/////
//class file_exception : public libc_exception {
//public:
//			file_exception (const char* operation, const char* filename) throw();
//    inline virtual const char* what (void) const throw() { return ("file error"); }
//    virtual void	info (string& msgbuf, const char* fmt = NULL) const throw();
//    virtual void	read (istream& is);
//    virtual void	write (ostream& os) const;
//    virtual size_t	stream_size (void) const;
//protected:
//    char		m_Filename [PATH_MAX];	///< Name of the file causing the error.
//};
//
///// \class stream_bounds_exception uexception.h ustl.h
///// \ingroup Exceptions
/////
///// \brief Stream bounds checking.
/////
///// Only thrown in debug builds unless you say otherwise in config.h
///// This is a uSTL extension.
/////
//class stream_bounds_exception : public libc_exception {
//public:
//			stream_bounds_exception (const char* operation, const char* type, uoff_t offset, size_t expected, size_t remaining) throw();
//    inline virtual const char*	what (void) const throw() { return ("stream bounds exception"); }
//    virtual void	info (string& msgbuf, const char* fmt = NULL) const throw();
//    virtual void	read (istream& is);
//    virtual void	write (ostream& os) const;
//    virtual size_t	stream_size (void) const;
//protected:
//    const char*		m_TypeName;
//    uoff_t		m_Offset;
//    size_t		m_Expected;
//    size_t		m_Remaining;
//};
//
//const char* demangle_type_name (char* buf, size_t bufSize, size_t* pdmSize = NULL);
//
//} // namespace ustl
//
//#endif
